package com.example.libpro.Service;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.text.TextUtils;

import androidx.annotation.Nullable;

import com.example.libpro.DAO.BookDAO;
import com.example.libpro.DAO.BorrowRecordDAO;
import com.example.libpro.DAO.ReaderDAO;
import com.example.libpro.DBEntity.BorrowRecordEntity;
import com.example.libpro.DBEntity.UserEntity;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;

/**
 * 图书管理系统读者管理业务服务类
 * 作用：1. 处理读者管理全流程业务逻辑，封装《安卓设计报告.docx》中"管理用户业务流程"（新增/修改/删除/查询读者）；
 * 2. 调用ReaderDAO实现数据访问，处理业务规则（如账号唯一性校验、删除前状态检查）；
 * 3. 为应用层（UserManager）提供标准化的读者管理接口，返回操作结果（成功/失败原因）。
 * 核心业务：读者信息校验、账号重复检查、逻辑删除处理、读者列表查询
 * 依赖：ReaderDAO（读者表CRUD操作）
 */
public class ReaderService extends Service {
    private static final String TAG = "ReaderService";
    private ReaderDAO readerDAO;
    private final IBinder binder = new ReaderService.LocalBinder();
    // 构造方法：初始化DAO
    /**
     * ReaderService构造方法
     * @param context Android上下文对象，用于初始化ReaderDAO
     * 功能：建立与数据管理层的连接，为读者管理业务提供数据访问能力
     */
    public ReaderService(Context context) {
        this.readerDAO = new ReaderDAO(context);
    }

    public ReaderService() {
        this.readerDAO = new ReaderDAO(null);
    }

    public class LocalBinder extends Binder {
        public ReaderService getService() {
            ReaderService.this.readerDAO = new ReaderDAO(getApplicationContext());
            return ReaderService.this;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }

    // 新增读者
    /**
     * 新增读者账号（完整流程：信息校验→账号重复检查→调用DAO插入）
     * @param account 读者账号（唯一，如学号）
     * @param password 初始密码（建议服务层加密后存储）
     * @param name 读者姓名
     * @return ServiceResult 操作结果（含成功标识、错误信息）
     * 业务规则：
     * 1. 信息校验：账号/密码/姓名不能为空；
     * 2. 账号唯一性：调用DAO查询该账号是否已存在（存在则返回"账号已被使用"）；
     * 3. 密码加密：与登录逻辑一致的加密方式；
     * 4. 插入数据：封装UserEntity调用ReaderDAO.insertReader()。
     * 适配报告：贴合《安卓设计报告.docx》"管理用户业务流程-新增读者→输入信息→提交→写入数据库"流程
     */
    public ServiceResult addReader(String account, String password, String name) {
        // 1. 信息校验
        if (TextUtils.isEmpty(account) || TextUtils.isEmpty(password) || TextUtils.isEmpty(name)) {
            return new ServiceResult(false, "账号、密码或姓名不能为空");
        }

        // 2. 检查账号是否已存在（通过查询验证唯一性）
        List<UserEntity> existingUsers = readerDAO.queryReaderByKeyword(account);
        for (UserEntity user : existingUsers) {
            if (account.equals(user.getAccount())) {
                return new ServiceResult(false, "账号已被使用，请更换账号");
            }
        }

        // 3. 密码加密
        //String encryptedPwd = encryptPassword(password);

        // 4. 封装实体并调用DAO插入
        UserEntity newReader = new UserEntity(account, password, name, 2, 0); // roleId=2（读者）
        boolean insertSuccess = readerDAO.insertReader(newReader);
        if (insertSuccess) {
            return new ServiceResult(true, "新增读者成功");
        } else {
            return new ServiceResult(false, "新增读者失败，请重试");
        }
    }

    // 修改读者信息
    /**
     * 修改读者信息（支持修改姓名、密码）
     * @param userId 读者ID（必须，用于定位修改对象）
     * @param newName 新姓名（可为null，不修改则传null）
     * @param newPassword 新密码（可为null，不修改则传null）
     * @return ServiceResult 操作结果
     * 业务规则：
     * 1. 必须指定userId（否则无法定位读者）；
     * 2. 至少修改一项信息（姓名或密码）；
     * 3. 密码修改时需加密；
     * 4. 调用DAO更新数据前，验证读者是否存在（未被删除）。
     * 适配报告：贴合《安卓设计报告.docx》"管理用户业务流程-编辑读者→修改信息→提交更新"流程
     */
    public ServiceResult updateReader(Integer userId, String newName, String newPassword) {
        // 1. 校验参数
        if (userId == null) {
            return new ServiceResult(false, "读者ID不能为空");
        }
        if (newName == null && newPassword == null) {
            return new ServiceResult(false, "至少需修改一项信息");
        }

        // 2. 验证读者是否存在（通过查询确认）
        List<UserEntity> readers = readerDAO.queryReaderByKeyword(""); // 查询所有读者
        UserEntity targetReader = null;
        for (UserEntity reader : readers) {
            if (userId.equals(reader.getUserId())) {
                targetReader = reader;
                break;
            }
        }
        if (targetReader == null) {
            return new ServiceResult(false, "读者不存在或已被删除");
        }

        // 3. 封装修改信息（含密码加密）
        UserEntity updateEntity = new UserEntity();
        updateEntity.setUserId(userId);
        if (newName != null) updateEntity.setName(newName);
        if (newPassword != null) updateEntity.setPassword(encryptPassword(newPassword));

        // 4. 调用DAO更新
        boolean updateSuccess = readerDAO.updateReader(updateEntity);
        if (updateSuccess) {
            return new ServiceResult(true, "修改读者信息成功");
        } else {
            return new ServiceResult(false, "修改读者信息失败，请重试");
        }
    }

    // 逻辑删除读者
    /**
     * 逻辑删除读者（将is_deleted设为1，而非物理删除）
     * @param userId 读者ID
     * @return ServiceResult 操作结果
     * 业务规则：
     * 1. 验证读者是否存在（未被删除）；
     * 2. 检查读者是否有未还借阅记录（有则禁止删除，返回"存在未还书籍，无法删除"）；
     * 3. 调用DAO执行逻辑删除。
     * 适配报告：贴合《安卓设计报告.docx》"管理用户业务流程-删除读者→确认→后台逻辑删除"流程
     */
    public ServiceResult deleteReader(Integer userId, BorrowRecordDAO borrowRecordDAO) {
        // 1. 校验参数
        if (userId == null) {
            return new ServiceResult(false, "读者ID不能为空");
        }

        // 2. 验证读者是否存在
        List<UserEntity> readers = readerDAO.queryReaderByKeyword("");
        boolean exists = false;
        for (UserEntity reader : readers) {
            if (userId.equals(reader.getUserId())) {
                exists = true;
                break;
            }
        }
        if (!exists) {
            return new ServiceResult(false, "读者不存在或已被删除");
        }

        // 3. 检查是否有未还记录（需依赖BorrowRecordDAO）
        List<BorrowRecordEntity> unreturnedRecords = borrowRecordDAO.queryBorrowRecordsByUserId(userId, 0); // 0=未还
        if (!unreturnedRecords.isEmpty()) {
            return new ServiceResult(false, "该读者存在未还书籍，无法删除");
        }

        // 4. 调用DAO执行逻辑删除
        boolean deleteSuccess = readerDAO.deleteReader(userId);
        if (deleteSuccess) {
            return new ServiceResult(true, "删除读者成功");
        } else {
            return new ServiceResult(false, "删除读者失败，请重试");
        }
    }

    // 关键字查询读者
    /**
     * 按账号或姓名关键字查询读者（仅返回未删除的读者）
     * @param keyword 查询关键字（支持账号、姓名模糊匹配）
     * @return ReaderQueryResult 查询结果（含成功标识、读者列表）
     * 业务逻辑：
     * 1. 直接调用ReaderDAO.queryReaderByKeyword()获取数据；
     * 2. 封装结果为ReaderQueryResult（便于应用层处理）。
     * 适配报告：贴合《安卓设计报告.docx》"管理用户业务流程-查询→输入关键字→返回匹配列表"流程
     */
    public ReaderQueryResult queryReader(String keyword) {
        List<UserEntity> readerList = readerDAO.queryReaderByKeyword(keyword);
        return new ReaderQueryResult(true, "查询成功", readerList);
    }

    // 辅助方法：密码加密（与登录逻辑一致）
    private String encryptPassword(String rawPassword) {
        // 复用LoginService的加密逻辑（实际项目建议抽取为工具类）
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] bytes = md.digest(rawPassword.getBytes());
            StringBuilder sb = new StringBuilder();
            for (byte b : bytes) {
                sb.append(String.format("%02x", b));
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return rawPassword;
        }
    }

    // 通用服务结果封装类
    public static class ServiceResult {
        private boolean success;
        private String message;

        public ServiceResult(boolean success, String message) {
            this.success = success;
            this.message = message;
        }

        public boolean isSuccess() { return success; }
        public String getMessage() { return message; }
    }

    // 读者查询结果封装类（含列表数据）
    public static class ReaderQueryResult extends ServiceResult {
        private List<UserEntity> readerList;

        public ReaderQueryResult(boolean success, String message, List<UserEntity> readerList) {
            super(success, message);
            this.readerList = readerList;
        }

        public List<UserEntity> getReaderList() { return readerList; }
    }


}